{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Rank Ordered Bayesian Optimization with Trust Regions (ROBOT)\n",
    "In this tutorial, we show how to implement Rank Ordered Bayesian Optimization with Trust Regions (ROBOT) [1] in a closed loop in BoTorch to optimize a set of $M$ diverse solutions ($M$ solutions that are pairwise diverse from one another) that all optimize the black-box objective function. \n",
    "\n",
    "In this tutorial, we demonstrate using ROBOT to find $M=3$ diverse solutions to a the rover trajectory optimization task, as in section 4.1.1 of the original paper [1].  \n",
    "\n",
    "[1]: [Maus, Natalie, et al. Discovering Many Diverse Solutions with Bayesian Optimization. AISTATS 2023.](https://proceedings.mlr.press/v206/maus23a/maus23a.pdf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "import os \n",
    "import numpy as np \n",
    "import torch \n",
    "import gpytorch \n",
    "import itertools\n",
    "import scipy.interpolate as si\n",
    "from dataclasses import dataclass\n",
    "from botorch.generation import MaxPosteriorSampling \n",
    "from torch.quasirandom import SobolEngine\n",
    "from torch.utils.data import TensorDataset, DataLoader\n",
    "from gpytorch.mlls import PredictiveLogLikelihood \n",
    "from gpytorch.models import ApproximateGP\n",
    "from gpytorch.variational import CholeskyVariationalDistribution\n",
    "from gpytorch.variational import VariationalStrategy\n",
    "from botorch.posteriors.gpytorch import GPyTorchPosterior\n",
    "from gpytorch.kernels.kernel import Distance\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.patches as patches\n",
    "\n",
    "dist_module = Distance()\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "dtype = torch.float64\n",
    "torch.set_default_dtype(torch.float64)\n",
    "torch.manual_seed(42);\n",
    "SMOKE_TEST = os.environ.get(\"SMOKE_TEST\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Define model class for GP surrogate model\n",
    "The GPModel class defined below is a standard approximate GP model defined using gpytorch. As in [1], we use an approximate GP model for increased speed when updating on large quantities of data. \n",
    "Additionally we define below a function update_gp that can be called to update the GP surrogate model on new data collected during optimization using gradient descent with the standard Adam optimizer. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class GPModel(ApproximateGP):\n",
    "    def __init__(self, inducing_points, likelihood):\n",
    "        variational_distribution = CholeskyVariationalDistribution(inducing_points.size(0) )\n",
    "        variational_strategy = VariationalStrategy(\n",
    "            self, \n",
    "            inducing_points, \n",
    "            variational_distribution, \n",
    "            learn_inducing_locations=True,\n",
    "        )\n",
    "        super(GPModel, self).__init__(variational_strategy)\n",
    "        self.mean_module = gpytorch.means.ConstantMean()\n",
    "        self.covar_module = gpytorch.kernels.ScaleKernel(gpytorch.kernels.RBFKernel())\n",
    "        self.num_outputs = 1\n",
    "        self.likelihood = likelihood \n",
    "\n",
    "    def forward(self, x):\n",
    "        mean_x = self.mean_module(x)\n",
    "        covar_x = self.covar_module(x)\n",
    "        return gpytorch.distributions.MultivariateNormal(mean_x, covar_x)\n",
    "\n",
    "    def posterior(\n",
    "            self, X, output_indices=None, observation_noise=False, *args, **kwargs\n",
    "        ) -> GPyTorchPosterior:\n",
    "            self.eval()  \n",
    "            self.likelihood.eval()\n",
    "            dist = self.likelihood(self(X)) \n",
    "            return GPyTorchPosterior(dist)\n",
    "\n",
    "def update_gp(\n",
    "    model,\n",
    "    mll,\n",
    "    train_x,\n",
    "    train_y,\n",
    "    n_epochs=2,\n",
    "    bsz=1024,\n",
    "    lr=0.01,\n",
    "):\n",
    "    model.train() \n",
    "    optimizer = torch.optim.Adam([{'params': model.parameters(), 'lr': lr} ], lr=lr)\n",
    "    train_bsz = min(len(train_y),bsz)\n",
    "    train_dataset = TensorDataset(train_x.to(device=device), train_y.squeeze().to(device=device))\n",
    "    train_loader = DataLoader(train_dataset, batch_size=train_bsz, shuffle=True)\n",
    "    for _ in range(n_epochs):\n",
    "        for (inputs, scores) in train_loader:\n",
    "            optimizer.zero_grad()\n",
    "            output = model(inputs.to(device=device))\n",
    "            loss = -mll(output, scores.to(device=device))\n",
    "            loss.backward()\n",
    "            torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)\n",
    "            optimizer.step()\n",
    "    model.eval()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Trust region dynamics \n",
    "ROBOT [1] utilizes $M$ collaborative trust regions to discover a set of $M$ diverse solutions. Below, we define the standard trust region state data class, and a method for updating the state of the trust region, as defined in the original Trust Region Bayesian Optimization (TuRBO) paper [2]. \n",
    "\n",
    "[2]: [Eriksson, David, et al. Scalable global optimization via local Bayesian optimization. NeurIPS 2019.](https://proceedings.neurips.cc/paper/2019/file/6c990b7aca7bc7058f5e98ea909e924b-Paper.pdf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@dataclass\n",
    "class TrustRegionState:\n",
    "    center_point: torch.Tensor | None =  None \n",
    "    best_value: float = -float(\"inf\") \n",
    "    length: float = 0.8 \n",
    "    length_min: float = 0.5 ** 7\n",
    "    length_max: float = 1.6\n",
    "    failure_counter: int = 0\n",
    "    failure_tolerance: int = 32 \n",
    "    success_counter: int = 0\n",
    "    success_tolerance: int = 10 \n",
    "    restart_triggered: bool = False\n",
    "\n",
    "\n",
    "def update_state(state: TrustRegionState, Y_next):\n",
    "    if max(Y_next) > state.best_value + 1e-3 * math.fabs(state.best_value):\n",
    "        state.success_counter += 1\n",
    "        state.failure_counter = 0\n",
    "    else:\n",
    "        state.success_counter = 0\n",
    "        state.failure_counter += len(Y_next) \n",
    "\n",
    "    if state.success_counter == state.success_tolerance:  # Expand trust region\n",
    "        state.length = min(2.0 * state.length, state.length_max)\n",
    "        state.success_counter = 0\n",
    "    elif state.failure_counter == state.failure_tolerance:  # Shrink trust region\n",
    "        state.length /= 2.0\n",
    "        state.failure_counter = 0\n",
    "\n",
    "    state.best_value = max(state.best_value, max(Y_next).item())\n",
    "    if state.length < state.length_min:\n",
    "        state.restart_triggered = True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Acquisition (generating candidate points)\n",
    "On each iteration of optimization, ROBOT [1] uses Thompson sampling to generate candidates from within each of the $M$ trust regions. Thompson sampling is straightforward to implement using BoTorch."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_batch(\n",
    "    tr_state, # trust region where we want to generate new candidates\n",
    "    model, # GP surrogate model\n",
    "    dim, # search space dim\n",
    "    batch_size, # number of candidates to generate (acquisition batch size)\n",
    "    lb, # lower bound of search space\n",
    "    ub, # upper bound of search space\n",
    "):\n",
    "    # Generate batch of candidate points by Thompson sampling in the trust region tr_state\n",
    "    n_candidates = min(5000, max(2000, 200 * dim))\n",
    "    x_center = tr_state.center_point\n",
    "    weights = torch.ones_like(x_center)\n",
    "    weights = weights * (ub - lb)\n",
    "    tr_lb = torch.clamp(x_center - weights * tr_state.length / 2.0, lb, ub) \n",
    "    tr_ub = torch.clamp(x_center + weights * tr_state.length / 2.0, lb, ub) \n",
    "    tr_lb = tr_lb.to(dtype=dtype,device=device)\n",
    "    tr_ub = tr_ub.to(dtype=dtype,device=device)\n",
    "    sobol = SobolEngine(dim, scramble=True) \n",
    "    pert = sobol.draw(n_candidates).to(dtype=dtype,device=device)\n",
    "    pert = tr_lb + (tr_ub - tr_lb) * pert\n",
    "    tr_lb = tr_lb.to(dtype=dtype,device=device)\n",
    "    tr_ub = tr_ub.to(dtype=dtype,device=device)\n",
    "    # Create a perturbation mask \n",
    "    prob_perturb = min(20.0 / dim, 1.0)\n",
    "    mask = (torch.rand(n_candidates, dim, dtype=dtype, device=device)<= prob_perturb)\n",
    "    ind = torch.where(mask.sum(dim=1) == 0)[0]\n",
    "    mask[ind, torch.randint(0, dim - 1, size=(len(ind),), device=device)] = 1\n",
    "    mask = mask.to(device=device)\n",
    "    # Create candidate points from the perturbations and the mask\n",
    "    X_cand = x_center.expand(n_candidates, dim).clone()\n",
    "    X_cand = X_cand.to(dtype=dtype,device=device)\n",
    "    pert = pert.to(dtype=dtype,device=device)\n",
    "    X_cand[mask] = pert[mask]\n",
    "    # Sample on the candidate points \n",
    "    thompson_sampling = MaxPosteriorSampling(model=model, replacement=False ) \n",
    "    X_next = thompson_sampling(X_cand.to(dtype=dtype,device=device), num_samples=batch_size )\n",
    "\n",
    "    return X_next"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set up the rover black-box optimization task \n",
    "In ths notebook, we optimize the same rover trajectory optimization task considered in [1]. The task consists of finding a 60 dimensional policy that allows a rover to move along some trajectory from a designated start point, to the \"goal\" point, while avoiding a set of obstacles. This optimization problem is useful for demonstrating the usefulness of ROBOT as it allows us to directly visualize the diverse solutions (trajectories) found by ROBOT. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class RoverObjective:\n",
    "    def __init__(self,):\n",
    "        self.dim = 60 \n",
    "        self.lb =  -0.5 * 4 / self.dim \n",
    "        self.ub = 4 / self.dim \n",
    "        self.f_max = 5.0 \n",
    "        self.const_cost_val = 0.05\n",
    "        self.const_obs_cost_val = 20.0\n",
    "        a = [0.0, 0.2, 0.4, 0.6, 0.8, 1.0]\n",
    "        c = np.array(list(itertools.product(a, a)))  \n",
    "        c = c[1:-1] \n",
    "        self.obstacle_delta = 0.1\n",
    "        self.obstacle_l = c - self.obstacle_delta / 2\n",
    "        self.obstacle_h = c + self.obstacle_delta / 2\n",
    "        r_box = np.array([[0.5, 0.5]])\n",
    "        self.r_l = r_box - 0.5\n",
    "        self.r_h = r_box + 0.5\n",
    "        self.start = np.zeros(2) + 0.05\n",
    "        self.goal = np.array([0.95, 0.95])\n",
    "\n",
    "\n",
    "    # return the negative cost which we seek to optimize \n",
    "    def __call__(self, params):\n",
    "        points = self.get_trajectory_points(params)\n",
    "        # compute cost \n",
    "        trees_contain = self.contains(X=points, lows=self.obstacle_l, highs=self.obstacle_h)\n",
    "        r_box_contain = self.contains(X=points, lows=self.r_l, highs=self.r_h)\n",
    "        obstacle_cost = self.const_obs_cost_val * np.any(np.hstack([trees_contain, ~r_box_contain]), axis=1, keepdims=True)\n",
    "        constant_cost = self.get_constant_cost(points)\n",
    "        costs = np.sum(np.hstack([obstacle_cost, constant_cost]), axis=1)\n",
    "        # estimate (trapezoidal) the integral of the cost along traj \n",
    "        avg_cost = 0.5 * (costs[:-1] + costs[1:])\n",
    "        l = np.linalg.norm(points[1:] - points[:-1], axis=1)\n",
    "        total_cost = np.sum(l * avg_cost)\n",
    "        total_cost += 100 * np.linalg.norm(points[-1] - self.goal, 1)\n",
    "        reward = total_cost*-1 + self.f_max \n",
    "        return reward.item() \n",
    "\n",
    "    def get_constant_cost(self, X):\n",
    "        if X.ndim == 1:\n",
    "            X = X[None, :]\n",
    "        return np.ones((X.shape[0], 1)) * self.const_cost_val\n",
    "\n",
    "    def contains(self, X, lows, highs):\n",
    "        if X.ndim == 1:\n",
    "            X = X[None, :]\n",
    "        lX = lows.T[None, :, :] <= X[:, :, None]\n",
    "        hX = highs.T[None, :, :] > X[:, :, None]\n",
    "        return lX.all(axis=1) & hX.all(axis=1)\n",
    "\n",
    "    def get_trajectory_points(self, params):\n",
    "        points = np.hstack((self.start[:, None], params.reshape((-1, 2)).T)).cumsum(axis=1)\n",
    "        xp = points[0]\n",
    "        yp = points[1]\n",
    "        okay = np.where(np.abs(np.diff(xp)) + np.abs(np.diff(yp)) > 0)\n",
    "        xp = np.r_[xp[okay], xp[-1]]\n",
    "        yp = np.r_[yp[okay], yp[-1]] \n",
    "        tck, _ = si.splprep([xp, yp], k=3, s=0)\n",
    "        spacing = np.linspace(0, 1.0, 1000, endpoint=True)\n",
    "        points = np.vstack(si.splev(spacing, tck)).T\n",
    "        return points \n",
    "\n",
    "# create rover objective function \n",
    "rover_objective = RoverObjective()\n",
    "\n",
    "# define a function to make it easier to call the black-box objective function a batch of candidate points\n",
    "def f_batch(x_batch):\n",
    "    rewards = []\n",
    "    for x in x_batch:\n",
    "        rewards.append(rover_objective(x))\n",
    "    return torch.tensor(rewards).to(dtype=dtype, device=device).unsqueeze(-1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Visualizing the rover optimization task \n",
    "Below, we provide a visualization of the rover task. The start point for the rover is shown in green. The \"goal\" point that the rover tries to reach is shown in red. The obstacles that the rover must avoid on its way from the start point to the goal point are shown as dark red rectangles. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "_, ax = plt.subplots(1, 1, figsize=(8, 6))\n",
    "# Depict obstacles as dark red rectangles \n",
    "for i in range(len(rover_objective.obstacle_l)):\n",
    "    rect = patches.Rectangle(\n",
    "        (rover_objective.obstacle_l[i, 0], rover_objective.obstacle_l[i, 1]),\n",
    "        rover_objective.obstacle_delta,\n",
    "        rover_objective.obstacle_delta,\n",
    "        linewidth=1,\n",
    "        edgecolor=\"darkred\",\n",
    "        facecolor=\"darkred\",\n",
    "    )\n",
    "    ax.add_patch(rect) \n",
    "plt.plot(0.05, 0.05, \".g\", ms=25, label=\"Start\") # Start\n",
    "plt.plot(0.95, 0.95, \".r\", ms=25, label=\"Goal\") # Goal\n",
    "plt.legend()\n",
    "plt.grid(True)\n",
    "plt.title(\"Rover Optimization Task Visualization\")\n",
    "# Add grid lines\n",
    "ax.grid(True)\n",
    "# Turn off axis labels (numbers) but keep ticks (and thus the grid lines)\n",
    "ax.set_xticklabels([])  # Remove x-axis tick labels\n",
    "ax.set_yticklabels([])  # Remove y-axis tick labels\n",
    "plt.show();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Diversity function and threshold\n",
    "In addition to a black-box function to optimize, ROBOT [1] requires a user-defined diversity function $\\delta$ and a diversity threshold $\\tau$. ROBOT applies constraints such that any pair of solutions in its optimized set of $M$ solutions must have a diversity score (according to $\\delta$) of at least $\\tau$. \n",
    "\n",
    "For the rover optimization task, as in the original paper [1], we define the diversity function as the \"one way distance\" between a pair of paths taken by the rover, and we use $\\tau=0.15$. Thus, the $M$ solutions found by ROBOT must be meaningfully diverse from one another, as the solutions are forced to take distinct routes around the obstacles. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def delta(x1, x2 ):\n",
    "    ''' Returns one way distance (OWD) (https://zheng-kai.com/paper/vldbj_2019.pdf)\n",
    "        between two the trajectories/paths taken by the rover \n",
    "            d_proj(A,B) = (1/N_points) * Sum of Euclidian dist from each point in the A, to NEAREST point in the B \n",
    "            OWD(A, B) = mean(d_proj(A, B), d_proj(B, A)) --> symmetric distance metric \n",
    "    '''\n",
    "    trajA = rover_objective.get_trajectory_points(x1)\n",
    "    trajB = rover_objective.get_trajectory_points(x2)\n",
    "    trajA = torch.from_numpy(trajA)\n",
    "    trajB = torch.from_numpy(trajB)\n",
    "    N = trajA.shape[-2]\n",
    "    trajA, trajB = trajA.to(dtype=dtype,device=device), trajB.to(dtype=dtype,device=device)\n",
    "    dist_matrix = dist_module._dist(trajA, trajB, postprocess=False)\n",
    "    dists_AB, _ = torch.min(dist_matrix, dim=-1)\n",
    "    dists_BA, _ = torch.min(dist_matrix, dim=-2) \n",
    "    return 0.5*( (dists_AB.sum(dim=-1)/N)+(dists_BA.sum(dim=-1)/N) )\n",
    "\n",
    "TAU = 0.15\n",
    "\n",
    "def is_feasible(cand_x, higher_ranked_xs): \n",
    "    '''\n",
    "    Helper function used to check if a candidate point cand_x \n",
    "        is sufficiently diverse from all points in the list higher_ranked_xs\n",
    "    '''\n",
    "    for x in higher_ranked_xs:\n",
    "        if delta(cand_x, x) < TAU:\n",
    "            return False \n",
    "    return True "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ROBOT trust region recentering \n",
    "On each iteration of ROBOT, the $M$ trust regions are re-centered on the best feasible set of $M$ solutions found so far. Here, \"feasible\" means that the $M$ solutions meet the diversity constraints according to the diversity function $\\delta$ and a diversity threshold $\\tau$ defined above. The $M$ solutions are selected from all observed data greedily: ROBOT first selects the single best scoring data point, then the best remaining data point that is sufficiently diverse from the first, then the best remaining data point that is sufficiently diverse from the first two points, and so on. This hierarchical greedy selection of trust region centers maintains the diversity constraints while ensuring that higher ranking trust regions are unimpeeded by lower ranking ones. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def recenter_trs(train_x, train_y, rank_ordered_trs):\n",
    "    # recenter trust regions on best diverse set found so far\n",
    "    tr_center_ys = []\n",
    "    tr_center_xs = []\n",
    "    idx_num = 0\n",
    "    _, top_t_idxs = torch.topk(train_y.squeeze(), len(train_y))\n",
    "    for tr_state in rank_ordered_trs:\n",
    "        while True: \n",
    "            # otherwise, finding highest scoring feassible point in remaining dataset for tr center\n",
    "            center_idx = top_t_idxs[idx_num]\n",
    "            center_y = train_y[center_idx].item()\n",
    "            center_x = train_x[center_idx]\n",
    "            idx_num += 1\n",
    "            if is_feasible(cand_x=center_x, higher_ranked_xs=tr_center_xs):\n",
    "                break \n",
    "\n",
    "        tr_center_xs.append(center_x) \n",
    "        tr_center_ys.append(center_y)\n",
    "        tr_state.center_point = center_x # center point in search space where TR is defined\n",
    "        tr_state.best_value = center_y\n",
    "\n",
    "    return tr_center_xs, tr_center_ys"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Generate initialization data \n",
    "Initialize ROBOT with points sampled uniformly at random within the search space. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_initialization_points = 1024 if not SMOKE_TEST else 256\n",
    "train_x = torch.rand(n_initialization_points, rover_objective.dim)*(rover_objective.ub - rover_objective.lb) + rover_objective.lb \n",
    "train_x = train_x.to(dtype=dtype, device=device)\n",
    "train_y = f_batch(train_x) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initialize GP surrogate model\n",
    "ROBOT uses a single global GP surrogate model to enable data sharing between the $M$ local optimizers. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "likelihood = gpytorch.likelihoods.GaussianLikelihood().to(device=device)\n",
    "model = GPModel(inducing_points=train_x, likelihood=likelihood ).to(device=device)\n",
    "mll = PredictiveLogLikelihood(model.likelihood, model, num_data=train_x.size(-2))\n",
    "# Condition the GP on the initializaiotn data \n",
    "n_init_update_epochs = 10 if not SMOKE_TEST else 1 \n",
    "update_gp(\n",
    "    model=model,\n",
    "    mll=mll,\n",
    "    train_x=train_x,\n",
    "    train_y=train_y,\n",
    "    n_epochs=n_init_update_epochs, \n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Run ROBOT\n",
    "Here we implement the main optimization loop to find a set of $M=3$ diverse solutions to the rover optimization task with ROBOT. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "After 1 iterations and 63 oracle calls, mean reward of best M=3 diverse solutions = -31.428054830864784\n",
      "After 2 iterations and 122 oracle calls, mean reward of best M=3 diverse solutions = -32.21134695680481\n",
      "After 3 iterations and 166 oracle calls, mean reward of best M=3 diverse solutions = -31.76185546921702\n",
      "After 4 iterations and 211 oracle calls, mean reward of best M=3 diverse solutions = -31.259834076762388\n",
      "After 5 iterations and 268 oracle calls, mean reward of best M=3 diverse solutions = -25.668475010682297\n",
      "After 6 iterations and 336 oracle calls, mean reward of best M=3 diverse solutions = -23.217788719496124\n",
      "After 7 iterations and 386 oracle calls, mean reward of best M=3 diverse solutions = -20.98863522900998\n",
      "After 8 iterations and 434 oracle calls, mean reward of best M=3 diverse solutions = -19.51594943646553\n",
      "After 9 iterations and 480 oracle calls, mean reward of best M=3 diverse solutions = -19.51594943646553\n",
      "After 10 iterations and 536 oracle calls, mean reward of best M=3 diverse solutions = -17.264784483958987\n",
      "After 11 iterations and 592 oracle calls, mean reward of best M=3 diverse solutions = -16.210226874340464\n",
      "After 12 iterations and 653 oracle calls, mean reward of best M=3 diverse solutions = -16.026923392266294\n",
      "After 13 iterations and 713 oracle calls, mean reward of best M=3 diverse solutions = -16.026923392266294\n",
      "After 14 iterations and 765 oracle calls, mean reward of best M=3 diverse solutions = -15.707457385895685\n",
      "After 15 iterations and 837 oracle calls, mean reward of best M=3 diverse solutions = -14.346688993656564\n",
      "After 16 iterations and 886 oracle calls, mean reward of best M=3 diverse solutions = -12.459290884241483\n",
      "After 17 iterations and 959 oracle calls, mean reward of best M=3 diverse solutions = -11.559947318180471\n",
      "After 18 iterations and 1013 oracle calls, mean reward of best M=3 diverse solutions = -11.559947318180471\n",
      "After 19 iterations and 1062 oracle calls, mean reward of best M=3 diverse solutions = -11.543595250725597\n",
      "After 20 iterations and 1116 oracle calls, mean reward of best M=3 diverse solutions = -10.98940080997248\n",
      "After 21 iterations and 1153 oracle calls, mean reward of best M=3 diverse solutions = -10.98940080997248\n",
      "After 22 iterations and 1193 oracle calls, mean reward of best M=3 diverse solutions = -10.98940080997248\n",
      "After 23 iterations and 1238 oracle calls, mean reward of best M=3 diverse solutions = -10.98940080997248\n",
      "After 24 iterations and 1278 oracle calls, mean reward of best M=3 diverse solutions = -10.76587936309456\n",
      "After 25 iterations and 1339 oracle calls, mean reward of best M=3 diverse solutions = -10.76587936309456\n",
      "After 26 iterations and 1397 oracle calls, mean reward of best M=3 diverse solutions = -9.885716405128031\n",
      "After 27 iterations and 1458 oracle calls, mean reward of best M=3 diverse solutions = -9.885716405128031\n",
      "After 28 iterations and 1494 oracle calls, mean reward of best M=3 diverse solutions = -9.885716405128031\n",
      "After 29 iterations and 1538 oracle calls, mean reward of best M=3 diverse solutions = -8.576119498488788\n",
      "After 30 iterations and 1600 oracle calls, mean reward of best M=3 diverse solutions = -8.42877238390465\n",
      "After 31 iterations and 1661 oracle calls, mean reward of best M=3 diverse solutions = -8.42877238390465\n",
      "After 32 iterations and 1720 oracle calls, mean reward of best M=3 diverse solutions = -6.427209165154516\n",
      "After 33 iterations and 1775 oracle calls, mean reward of best M=3 diverse solutions = -6.170117412403866\n",
      "After 34 iterations and 1830 oracle calls, mean reward of best M=3 diverse solutions = -6.170117412403866\n",
      "After 35 iterations and 1863 oracle calls, mean reward of best M=3 diverse solutions = -6.170117412403866\n",
      "After 36 iterations and 1900 oracle calls, mean reward of best M=3 diverse solutions = -6.170117412403866\n",
      "After 37 iterations and 1955 oracle calls, mean reward of best M=3 diverse solutions = -6.170117412403866\n",
      "After 38 iterations and 2016 oracle calls, mean reward of best M=3 diverse solutions = -6.170117412403866\n",
      "After 39 iterations and 2076 oracle calls, mean reward of best M=3 diverse solutions = -5.2340191870694746\n",
      "After 40 iterations and 2131 oracle calls, mean reward of best M=3 diverse solutions = -5.2340191870694746\n",
      "After 41 iterations and 2178 oracle calls, mean reward of best M=3 diverse solutions = -3.2871579029220186\n",
      "After 42 iterations and 2211 oracle calls, mean reward of best M=3 diverse solutions = -3.2871579029220186\n",
      "After 43 iterations and 2266 oracle calls, mean reward of best M=3 diverse solutions = -3.2871579029220186\n",
      "After 44 iterations and 2316 oracle calls, mean reward of best M=3 diverse solutions = -3.2871579029220186\n",
      "After 45 iterations and 2367 oracle calls, mean reward of best M=3 diverse solutions = -3.2871579029220186\n",
      "After 46 iterations and 2424 oracle calls, mean reward of best M=3 diverse solutions = -3.2871579029220186\n",
      "After 47 iterations and 2479 oracle calls, mean reward of best M=3 diverse solutions = -3.2871579029220186\n",
      "After 48 iterations and 2537 oracle calls, mean reward of best M=3 diverse solutions = -3.272574981494405\n",
      "After 49 iterations and 2585 oracle calls, mean reward of best M=3 diverse solutions = -3.272574981494405\n",
      "After 50 iterations and 2617 oracle calls, mean reward of best M=3 diverse solutions = -3.272574981494405\n",
      "After 51 iterations and 2659 oracle calls, mean reward of best M=3 diverse solutions = -3.272574981494405\n",
      "After 52 iterations and 2715 oracle calls, mean reward of best M=3 diverse solutions = -3.2675526600087763\n",
      "After 53 iterations and 2760 oracle calls, mean reward of best M=3 diverse solutions = -3.2675526600087763\n",
      "After 54 iterations and 2812 oracle calls, mean reward of best M=3 diverse solutions = -3.2675526600087763\n",
      "After 55 iterations and 2865 oracle calls, mean reward of best M=3 diverse solutions = -3.2675526600087763\n",
      "After 56 iterations and 2919 oracle calls, mean reward of best M=3 diverse solutions = -3.2503571536799796\n",
      "After 57 iterations and 2970 oracle calls, mean reward of best M=3 diverse solutions = -3.2503571536799796\n",
      "After 58 iterations and 3021 oracle calls, mean reward of best M=3 diverse solutions = -3.2503571536799796\n",
      "After 59 iterations and 3053 oracle calls, mean reward of best M=3 diverse solutions = -3.2503571536799796\n",
      "After 60 iterations and 3091 oracle calls, mean reward of best M=3 diverse solutions = -3.2503571536799796\n",
      "After 61 iterations and 3144 oracle calls, mean reward of best M=3 diverse solutions = -3.2503571536799796\n",
      "After 62 iterations and 3196 oracle calls, mean reward of best M=3 diverse solutions = -3.2503571536799796\n",
      "After 63 iterations and 3243 oracle calls, mean reward of best M=3 diverse solutions = -3.1042328795456235\n",
      "After 64 iterations and 3307 oracle calls, mean reward of best M=3 diverse solutions = -2.706589262268904\n",
      "After 65 iterations and 3357 oracle calls, mean reward of best M=3 diverse solutions = -2.706589262268904\n",
      "After 66 iterations and 3389 oracle calls, mean reward of best M=3 diverse solutions = -2.706589262268904\n",
      "After 67 iterations and 3425 oracle calls, mean reward of best M=3 diverse solutions = -2.706589262268904\n",
      "After 68 iterations and 3468 oracle calls, mean reward of best M=3 diverse solutions = -2.706589262268904\n",
      "After 69 iterations and 3525 oracle calls, mean reward of best M=3 diverse solutions = -2.706589262268904\n",
      "After 70 iterations and 3581 oracle calls, mean reward of best M=3 diverse solutions = -2.706589262268904\n",
      "After 71 iterations and 3648 oracle calls, mean reward of best M=3 diverse solutions = -2.706589262268904\n",
      "After 72 iterations and 3713 oracle calls, mean reward of best M=3 diverse solutions = -2.706589262268904\n",
      "After 73 iterations and 3746 oracle calls, mean reward of best M=3 diverse solutions = -2.706589262268904\n",
      "After 74 iterations and 3785 oracle calls, mean reward of best M=3 diverse solutions = -2.706589262268904\n",
      "After 75 iterations and 3833 oracle calls, mean reward of best M=3 diverse solutions = -2.706589262268904\n",
      "After 76 iterations and 3888 oracle calls, mean reward of best M=3 diverse solutions = -2.706589262268904\n",
      "After 77 iterations and 3938 oracle calls, mean reward of best M=3 diverse solutions = -2.706589262268904\n",
      "After 78 iterations and 3999 oracle calls, mean reward of best M=3 diverse solutions = -2.706589262268904\n",
      "After 79 iterations and 4057 oracle calls, mean reward of best M=3 diverse solutions = -1.7982759232803351\n",
      "After 80 iterations and 4092 oracle calls, mean reward of best M=3 diverse solutions = -1.7982759232803351\n",
      "After 81 iterations and 4133 oracle calls, mean reward of best M=3 diverse solutions = -1.7982759232803351\n",
      "After 82 iterations and 4189 oracle calls, mean reward of best M=3 diverse solutions = -1.7982759232803351\n",
      "After 83 iterations and 4236 oracle calls, mean reward of best M=3 diverse solutions = -1.7982759232803351\n",
      "After 84 iterations and 4287 oracle calls, mean reward of best M=3 diverse solutions = -1.7982759232803351\n",
      "After 85 iterations and 4338 oracle calls, mean reward of best M=3 diverse solutions = -1.7982759232803351\n",
      "After 86 iterations and 4384 oracle calls, mean reward of best M=3 diverse solutions = -1.7982759232803351\n",
      "After 87 iterations and 4416 oracle calls, mean reward of best M=3 diverse solutions = -1.7982759232803351\n",
      "After 88 iterations and 4457 oracle calls, mean reward of best M=3 diverse solutions = -1.7982759232803351\n",
      "After 89 iterations and 4499 oracle calls, mean reward of best M=3 diverse solutions = -1.7982759232803351\n",
      "After 90 iterations and 4543 oracle calls, mean reward of best M=3 diverse solutions = -1.7982759232803351\n",
      "After 91 iterations and 4596 oracle calls, mean reward of best M=3 diverse solutions = -1.7982759232803351\n",
      "After 92 iterations and 4660 oracle calls, mean reward of best M=3 diverse solutions = 0.5912359895636223\n",
      "After 93 iterations and 4707 oracle calls, mean reward of best M=3 diverse solutions = 0.5912359895636223\n",
      "After 94 iterations and 4739 oracle calls, mean reward of best M=3 diverse solutions = 0.5912359895636223\n",
      "After 95 iterations and 4776 oracle calls, mean reward of best M=3 diverse solutions = 0.5912359895636223\n",
      "After 96 iterations and 4826 oracle calls, mean reward of best M=3 diverse solutions = 0.5912359895636223\n",
      "After 97 iterations and 4876 oracle calls, mean reward of best M=3 diverse solutions = 0.5912359895636223\n",
      "After 98 iterations and 4936 oracle calls, mean reward of best M=3 diverse solutions = 0.5912359895636223\n",
      "After 99 iterations and 4996 oracle calls, mean reward of best M=3 diverse solutions = 0.5912359895636223\n",
      "After 100 iterations and 5064 oracle calls, mean reward of best M=3 diverse solutions = 0.6495543246081041\n",
      "After 101 iterations and 5098 oracle calls, mean reward of best M=3 diverse solutions = 0.6495543246081041\n",
      "After 102 iterations and 5139 oracle calls, mean reward of best M=3 diverse solutions = 0.6495543246081041\n",
      "After 103 iterations and 5189 oracle calls, mean reward of best M=3 diverse solutions = 0.6495543246081041\n",
      "After 104 iterations and 5240 oracle calls, mean reward of best M=3 diverse solutions = 0.6495543246081041\n",
      "After 105 iterations and 5295 oracle calls, mean reward of best M=3 diverse solutions = 0.6495543246081041\n",
      "After 106 iterations and 5361 oracle calls, mean reward of best M=3 diverse solutions = 0.6495543246081041\n",
      "After 107 iterations and 5423 oracle calls, mean reward of best M=3 diverse solutions = 0.6495543246081041\n",
      "After 108 iterations and 5458 oracle calls, mean reward of best M=3 diverse solutions = 0.6495543246081041\n",
      "After 109 iterations and 5497 oracle calls, mean reward of best M=3 diverse solutions = 0.6495543246081041\n",
      "After 110 iterations and 5537 oracle calls, mean reward of best M=3 diverse solutions = 0.6495543246081041\n",
      "After 111 iterations and 5594 oracle calls, mean reward of best M=3 diverse solutions = 0.6495543246081041\n",
      "After 112 iterations and 5649 oracle calls, mean reward of best M=3 diverse solutions = 0.6495543246081041\n",
      "After 113 iterations and 5702 oracle calls, mean reward of best M=3 diverse solutions = 0.6495543246081041\n",
      "After 114 iterations and 5759 oracle calls, mean reward of best M=3 diverse solutions = 0.6507109440589568\n",
      "After 115 iterations and 5813 oracle calls, mean reward of best M=3 diverse solutions = 0.6612644393749921\n",
      "After 116 iterations and 5845 oracle calls, mean reward of best M=3 diverse solutions = 0.6612644393749921\n",
      "After 117 iterations and 5885 oracle calls, mean reward of best M=3 diverse solutions = 0.6612644393749921\n",
      "After 118 iterations and 5926 oracle calls, mean reward of best M=3 diverse solutions = 0.8505783225335429\n",
      "After 119 iterations and 5977 oracle calls, mean reward of best M=3 diverse solutions = 0.8505783225335429\n",
      "After 120 iterations and 6028 oracle calls, mean reward of best M=3 diverse solutions = 0.8729740175879925\n",
      "After 121 iterations and 6080 oracle calls, mean reward of best M=3 diverse solutions = 0.8729740175879925\n",
      "After 122 iterations and 6143 oracle calls, mean reward of best M=3 diverse solutions = 0.9219851258302304\n",
      "After 123 iterations and 6204 oracle calls, mean reward of best M=3 diverse solutions = 1.2634801585093054\n",
      "After 124 iterations and 6265 oracle calls, mean reward of best M=3 diverse solutions = 1.4828654450171677\n",
      "After 125 iterations and 6326 oracle calls, mean reward of best M=3 diverse solutions = 1.4828654450171677\n",
      "After 126 iterations and 6389 oracle calls, mean reward of best M=3 diverse solutions = 1.62069163247107\n",
      "After 127 iterations and 6453 oracle calls, mean reward of best M=3 diverse solutions = 1.6546959434388981\n",
      "After 128 iterations and 6528 oracle calls, mean reward of best M=3 diverse solutions = 2.2116473948932422\n",
      "After 129 iterations and 6560 oracle calls, mean reward of best M=3 diverse solutions = 2.2116473948932422\n",
      "After 130 iterations and 6595 oracle calls, mean reward of best M=3 diverse solutions = 2.2116473948932422\n",
      "After 131 iterations and 6635 oracle calls, mean reward of best M=3 diverse solutions = 2.2116473948932422\n",
      "After 132 iterations and 6679 oracle calls, mean reward of best M=3 diverse solutions = 2.2116473948932422\n",
      "After 133 iterations and 6731 oracle calls, mean reward of best M=3 diverse solutions = 2.2116473948932422\n",
      "After 134 iterations and 6797 oracle calls, mean reward of best M=3 diverse solutions = 2.2507278818788614\n",
      "After 135 iterations and 6850 oracle calls, mean reward of best M=3 diverse solutions = 2.546061404781347\n",
      "After 136 iterations and 6882 oracle calls, mean reward of best M=3 diverse solutions = 2.546061404781347\n",
      "After 137 iterations and 6914 oracle calls, mean reward of best M=3 diverse solutions = 2.546061404781347\n",
      "After 138 iterations and 6954 oracle calls, mean reward of best M=3 diverse solutions = 2.546061404781347\n",
      "After 139 iterations and 7000 oracle calls, mean reward of best M=3 diverse solutions = 2.546061404781347\n",
      "After 140 iterations and 7064 oracle calls, mean reward of best M=3 diverse solutions = 2.546061404781347\n",
      "After 141 iterations and 7115 oracle calls, mean reward of best M=3 diverse solutions = 2.546061404781347\n",
      "After 142 iterations and 7173 oracle calls, mean reward of best M=3 diverse solutions = 2.5483085245223402\n",
      "After 143 iterations and 7227 oracle calls, mean reward of best M=3 diverse solutions = 2.5483085245223402\n",
      "After 144 iterations and 7259 oracle calls, mean reward of best M=3 diverse solutions = 2.5483085245223402\n",
      "After 145 iterations and 7296 oracle calls, mean reward of best M=3 diverse solutions = 2.5483085245223402\n",
      "After 146 iterations and 7335 oracle calls, mean reward of best M=3 diverse solutions = 2.5483085245223402\n",
      "After 147 iterations and 7385 oracle calls, mean reward of best M=3 diverse solutions = 2.5483085245223402\n",
      "After 148 iterations and 7435 oracle calls, mean reward of best M=3 diverse solutions = 2.5483085245223402\n",
      "After 149 iterations and 7496 oracle calls, mean reward of best M=3 diverse solutions = 2.5483085245223402\n",
      "After 150 iterations and 7555 oracle calls, mean reward of best M=3 diverse solutions = 2.626545134246661\n",
      "After 151 iterations and 7587 oracle calls, mean reward of best M=3 diverse solutions = 2.626545134246661\n",
      "After 152 iterations and 7623 oracle calls, mean reward of best M=3 diverse solutions = 2.626545134246661\n",
      "After 153 iterations and 7664 oracle calls, mean reward of best M=3 diverse solutions = 2.626545134246661\n",
      "After 154 iterations and 7706 oracle calls, mean reward of best M=3 diverse solutions = 2.626545134246661\n",
      "After 155 iterations and 7763 oracle calls, mean reward of best M=3 diverse solutions = 2.626545134246661\n",
      "After 156 iterations and 7822 oracle calls, mean reward of best M=3 diverse solutions = 2.626545134246661\n",
      "After 157 iterations and 7882 oracle calls, mean reward of best M=3 diverse solutions = 2.880202354467189\n",
      "After 158 iterations and 7915 oracle calls, mean reward of best M=3 diverse solutions = 2.880202354467189\n",
      "After 159 iterations and 7948 oracle calls, mean reward of best M=3 diverse solutions = 2.880202354467189\n",
      "After 160 iterations and 7985 oracle calls, mean reward of best M=3 diverse solutions = 2.880202354467189\n",
      "After 161 iterations and 8035 oracle calls, mean reward of best M=3 diverse solutions = 2.880202354467189\n",
      "After 162 iterations and 8078 oracle calls, mean reward of best M=3 diverse solutions = 2.880202354467189\n",
      "After 163 iterations and 8144 oracle calls, mean reward of best M=3 diverse solutions = 2.9104744712874315\n",
      "After 164 iterations and 8203 oracle calls, mean reward of best M=3 diverse solutions = 3.106522532009471\n",
      "After 165 iterations and 8235 oracle calls, mean reward of best M=3 diverse solutions = 3.106522532009471\n",
      "After 166 iterations and 8269 oracle calls, mean reward of best M=3 diverse solutions = 3.106522532009471\n",
      "After 167 iterations and 8331 oracle calls, mean reward of best M=3 diverse solutions = 3.2318358398341593\n",
      "After 168 iterations and 8377 oracle calls, mean reward of best M=3 diverse solutions = 3.2318358398341593\n",
      "After 169 iterations and 8428 oracle calls, mean reward of best M=3 diverse solutions = 3.2318358398341593\n",
      "After 170 iterations and 8486 oracle calls, mean reward of best M=3 diverse solutions = 3.2318358398341593\n",
      "After 171 iterations and 8549 oracle calls, mean reward of best M=3 diverse solutions = 3.295024963821406\n",
      "After 172 iterations and 8583 oracle calls, mean reward of best M=3 diverse solutions = 3.295024963821406\n",
      "After 173 iterations and 8616 oracle calls, mean reward of best M=3 diverse solutions = 3.295024963821406\n",
      "After 174 iterations and 8652 oracle calls, mean reward of best M=3 diverse solutions = 3.295024963821406\n",
      "After 175 iterations and 8691 oracle calls, mean reward of best M=3 diverse solutions = 3.295024963821406\n",
      "After 176 iterations and 8745 oracle calls, mean reward of best M=3 diverse solutions = 3.295024963821406\n",
      "After 177 iterations and 8796 oracle calls, mean reward of best M=3 diverse solutions = 3.295024963821406\n",
      "After 178 iterations and 8853 oracle calls, mean reward of best M=3 diverse solutions = 3.3074993818821024\n",
      "After 179 iterations and 8885 oracle calls, mean reward of best M=3 diverse solutions = 3.3074993818821024\n",
      "After 180 iterations and 8919 oracle calls, mean reward of best M=3 diverse solutions = 3.3074993818821024\n",
      "After 181 iterations and 8955 oracle calls, mean reward of best M=3 diverse solutions = 3.3074993818821024\n",
      "After 182 iterations and 9001 oracle calls, mean reward of best M=3 diverse solutions = 3.3074993818821024\n",
      "After 183 iterations and 9061 oracle calls, mean reward of best M=3 diverse solutions = 3.3074993818821024\n",
      "After 184 iterations and 9113 oracle calls, mean reward of best M=3 diverse solutions = 3.4869462304713434\n",
      "After 185 iterations and 9183 oracle calls, mean reward of best M=3 diverse solutions = 3.546305345073664\n",
      "After 186 iterations and 9215 oracle calls, mean reward of best M=3 diverse solutions = 3.546305345073664\n",
      "After 187 iterations and 9249 oracle calls, mean reward of best M=3 diverse solutions = 3.546305345073664\n",
      "After 188 iterations and 9282 oracle calls, mean reward of best M=3 diverse solutions = 3.546305345073664\n",
      "After 189 iterations and 9340 oracle calls, mean reward of best M=3 diverse solutions = 3.546305345073664\n",
      "After 190 iterations and 9405 oracle calls, mean reward of best M=3 diverse solutions = 3.7490881321755727\n",
      "After 191 iterations and 9471 oracle calls, mean reward of best M=3 diverse solutions = 3.80761931321844\n",
      "After 192 iterations and 9533 oracle calls, mean reward of best M=3 diverse solutions = 3.80761931321844\n",
      "After 193 iterations and 9567 oracle calls, mean reward of best M=3 diverse solutions = 3.80761931321844\n",
      "After 194 iterations and 9600 oracle calls, mean reward of best M=3 diverse solutions = 3.80761931321844\n",
      "After 195 iterations and 9637 oracle calls, mean reward of best M=3 diverse solutions = 3.80761931321844\n",
      "After 196 iterations and 9678 oracle calls, mean reward of best M=3 diverse solutions = 3.80761931321844\n",
      "After 197 iterations and 9732 oracle calls, mean reward of best M=3 diverse solutions = 3.80761931321844\n",
      "After 198 iterations and 9789 oracle calls, mean reward of best M=3 diverse solutions = 3.80761931321844\n",
      "After 199 iterations and 9852 oracle calls, mean reward of best M=3 diverse solutions = 3.80761931321844\n",
      "After 200 iterations and 9885 oracle calls, mean reward of best M=3 diverse solutions = 3.80761931321844\n",
      "After 201 iterations and 9924 oracle calls, mean reward of best M=3 diverse solutions = 3.80761931321844\n",
      "After 202 iterations and 9960 oracle calls, mean reward of best M=3 diverse solutions = 3.80761931321844\n",
      "After 203 iterations and 10004 oracle calls, mean reward of best M=3 diverse solutions = 3.80761931321844\n",
      "After 204 iterations and 10068 oracle calls, mean reward of best M=3 diverse solutions = 3.80761931321844\n",
      "After 205 iterations and 10129 oracle calls, mean reward of best M=3 diverse solutions = 3.80761931321844\n",
      "After 206 iterations and 10191 oracle calls, mean reward of best M=3 diverse solutions = 3.9163694308938646\n",
      "After 207 iterations and 10223 oracle calls, mean reward of best M=3 diverse solutions = 3.9163694308938646\n",
      "After 208 iterations and 10261 oracle calls, mean reward of best M=3 diverse solutions = 3.9163694308938646\n",
      "After 209 iterations and 10297 oracle calls, mean reward of best M=3 diverse solutions = 3.9163694308938646\n",
      "After 210 iterations and 10359 oracle calls, mean reward of best M=3 diverse solutions = 3.9163694308938646\n",
      "After 211 iterations and 10432 oracle calls, mean reward of best M=3 diverse solutions = 4.088538204357804\n",
      "After 212 iterations and 10493 oracle calls, mean reward of best M=3 diverse solutions = 4.088538204357804\n",
      "After 213 iterations and 10558 oracle calls, mean reward of best M=3 diverse solutions = 4.103024226614095\n",
      "After 214 iterations and 10590 oracle calls, mean reward of best M=3 diverse solutions = 4.103024226614095\n",
      "After 215 iterations and 10622 oracle calls, mean reward of best M=3 diverse solutions = 4.103024226614095\n",
      "After 216 iterations and 10663 oracle calls, mean reward of best M=3 diverse solutions = 4.103024226614095\n",
      "After 217 iterations and 10706 oracle calls, mean reward of best M=3 diverse solutions = 4.103024226614095\n",
      "After 218 iterations and 10758 oracle calls, mean reward of best M=3 diverse solutions = 4.103024226614095\n",
      "After 219 iterations and 10814 oracle calls, mean reward of best M=3 diverse solutions = 4.103024226614095\n",
      "After 220 iterations and 10865 oracle calls, mean reward of best M=3 diverse solutions = 4.200641484922346\n",
      "After 221 iterations and 10898 oracle calls, mean reward of best M=3 diverse solutions = 4.200641484922346\n",
      "After 222 iterations and 10934 oracle calls, mean reward of best M=3 diverse solutions = 4.200641484922346\n",
      "After 223 iterations and 10977 oracle calls, mean reward of best M=3 diverse solutions = 4.200641484922346\n",
      "After 224 iterations and 11017 oracle calls, mean reward of best M=3 diverse solutions = 4.200641484922346\n",
      "After 225 iterations and 11069 oracle calls, mean reward of best M=3 diverse solutions = 4.200641484922346\n",
      "After 226 iterations and 11130 oracle calls, mean reward of best M=3 diverse solutions = 4.200641484922346\n",
      "After 227 iterations and 11193 oracle calls, mean reward of best M=3 diverse solutions = 4.200641484922346\n",
      "After 228 iterations and 11226 oracle calls, mean reward of best M=3 diverse solutions = 4.200641484922346\n",
      "After 229 iterations and 11266 oracle calls, mean reward of best M=3 diverse solutions = 4.200641484922346\n",
      "After 230 iterations and 11299 oracle calls, mean reward of best M=3 diverse solutions = 4.200641484922346\n",
      "After 231 iterations and 11341 oracle calls, mean reward of best M=3 diverse solutions = 4.200641484922346\n",
      "After 232 iterations and 11392 oracle calls, mean reward of best M=3 diverse solutions = 4.200641484922346\n",
      "After 233 iterations and 11446 oracle calls, mean reward of best M=3 diverse solutions = 4.258066093300081\n",
      "After 234 iterations and 11515 oracle calls, mean reward of best M=3 diverse solutions = 4.258066093300081\n",
      "After 235 iterations and 11548 oracle calls, mean reward of best M=3 diverse solutions = 4.258066093300081\n",
      "After 236 iterations and 11581 oracle calls, mean reward of best M=3 diverse solutions = 4.258066093300081\n",
      "After 237 iterations and 11615 oracle calls, mean reward of best M=3 diverse solutions = 4.258066093300081\n",
      "After 238 iterations and 11679 oracle calls, mean reward of best M=3 diverse solutions = 4.258066093300081\n",
      "After 239 iterations and 11748 oracle calls, mean reward of best M=3 diverse solutions = 4.271602940484988\n",
      "After 240 iterations and 11815 oracle calls, mean reward of best M=3 diverse solutions = 4.273059421638382\n",
      "After 241 iterations and 11883 oracle calls, mean reward of best M=3 diverse solutions = 4.354729128812437\n",
      "After 242 iterations and 11915 oracle calls, mean reward of best M=3 diverse solutions = 4.354729128812437\n",
      "After 243 iterations and 11958 oracle calls, mean reward of best M=3 diverse solutions = 4.354729128812437\n",
      "After 244 iterations and 12003 oracle calls, mean reward of best M=3 diverse solutions = 4.354729128812437\n",
      "After 245 iterations and 12047 oracle calls, mean reward of best M=3 diverse solutions = 4.354729128812437\n",
      "After 246 iterations and 12095 oracle calls, mean reward of best M=3 diverse solutions = 4.354729128812437\n",
      "After 247 iterations and 12164 oracle calls, mean reward of best M=3 diverse solutions = 4.354729128812437\n",
      "After 248 iterations and 12224 oracle calls, mean reward of best M=3 diverse solutions = 4.496423171591434\n",
      "After 249 iterations and 12256 oracle calls, mean reward of best M=3 diverse solutions = 4.496423171591434\n",
      "After 250 iterations and 12294 oracle calls, mean reward of best M=3 diverse solutions = 4.496423171591434\n",
      "After 251 iterations and 12333 oracle calls, mean reward of best M=3 diverse solutions = 4.496423171591434\n",
      "After 252 iterations and 12395 oracle calls, mean reward of best M=3 diverse solutions = 4.496423171591434\n",
      "After 253 iterations and 12476 oracle calls, mean reward of best M=3 diverse solutions = 4.520507254518538\n",
      "After 254 iterations and 12546 oracle calls, mean reward of best M=3 diverse solutions = 4.567149040359595\n",
      "After 255 iterations and 12614 oracle calls, mean reward of best M=3 diverse solutions = 4.573389701746069\n",
      "After 256 iterations and 12646 oracle calls, mean reward of best M=3 diverse solutions = 4.573389701746069\n",
      "After 257 iterations and 12678 oracle calls, mean reward of best M=3 diverse solutions = 4.573389701746069\n",
      "After 258 iterations and 12716 oracle calls, mean reward of best M=3 diverse solutions = 4.573389701746069\n",
      "After 259 iterations and 12750 oracle calls, mean reward of best M=3 diverse solutions = 4.573389701746069\n",
      "After 260 iterations and 12816 oracle calls, mean reward of best M=3 diverse solutions = 4.573389701746069\n",
      "After 261 iterations and 12883 oracle calls, mean reward of best M=3 diverse solutions = 4.630427022479602\n",
      "After 262 iterations and 12936 oracle calls, mean reward of best M=3 diverse solutions = 4.630427022479602\n",
      "After 263 iterations and 12970 oracle calls, mean reward of best M=3 diverse solutions = 4.630427022479602\n",
      "After 264 iterations and 13007 oracle calls, mean reward of best M=3 diverse solutions = 4.630427022479602\n",
      "After 265 iterations and 13049 oracle calls, mean reward of best M=3 diverse solutions = 4.630427022479602\n",
      "After 266 iterations and 13087 oracle calls, mean reward of best M=3 diverse solutions = 4.630427022479602\n",
      "After 267 iterations and 13132 oracle calls, mean reward of best M=3 diverse solutions = 4.630427022479602\n",
      "After 268 iterations and 13183 oracle calls, mean reward of best M=3 diverse solutions = 4.630427022479602\n",
      "After 269 iterations and 13235 oracle calls, mean reward of best M=3 diverse solutions = 4.6309611791294225\n",
      "After 270 iterations and 13269 oracle calls, mean reward of best M=3 diverse solutions = 4.6309611791294225\n",
      "After 271 iterations and 13306 oracle calls, mean reward of best M=3 diverse solutions = 4.6309611791294225\n",
      "After 272 iterations and 13346 oracle calls, mean reward of best M=3 diverse solutions = 4.6309611791294225\n",
      "After 273 iterations and 13388 oracle calls, mean reward of best M=3 diverse solutions = 4.6309611791294225\n",
      "After 274 iterations and 13430 oracle calls, mean reward of best M=3 diverse solutions = 4.6309611791294225\n",
      "After 275 iterations and 13471 oracle calls, mean reward of best M=3 diverse solutions = 4.6309611791294225\n",
      "After 276 iterations and 13543 oracle calls, mean reward of best M=3 diverse solutions = 4.654339943235154\n",
      "After 277 iterations and 13604 oracle calls, mean reward of best M=3 diverse solutions = 4.654339943235154\n",
      "After 278 iterations and 13641 oracle calls, mean reward of best M=3 diverse solutions = 4.654339943235154\n",
      "After 279 iterations and 13676 oracle calls, mean reward of best M=3 diverse solutions = 4.654339943235154\n",
      "After 280 iterations and 13716 oracle calls, mean reward of best M=3 diverse solutions = 4.654339943235154\n",
      "After 281 iterations and 13764 oracle calls, mean reward of best M=3 diverse solutions = 4.654339943235154\n",
      "After 282 iterations and 13808 oracle calls, mean reward of best M=3 diverse solutions = 4.654339943235154\n",
      "After 283 iterations and 13854 oracle calls, mean reward of best M=3 diverse solutions = 4.654339943235154\n",
      "After 284 iterations and 13922 oracle calls, mean reward of best M=3 diverse solutions = 4.654339943235154\n",
      "After 285 iterations and 13956 oracle calls, mean reward of best M=3 diverse solutions = 4.654339943235154\n",
      "After 286 iterations and 13991 oracle calls, mean reward of best M=3 diverse solutions = 4.654339943235154\n",
      "After 287 iterations and 14026 oracle calls, mean reward of best M=3 diverse solutions = 4.654339943235154\n",
      "After 288 iterations and 14076 oracle calls, mean reward of best M=3 diverse solutions = 4.654339943235154\n",
      "After 289 iterations and 14122 oracle calls, mean reward of best M=3 diverse solutions = 4.654339943235154\n",
      "After 290 iterations and 14164 oracle calls, mean reward of best M=3 diverse solutions = 4.654339943235154\n",
      "After 291 iterations and 14227 oracle calls, mean reward of best M=3 diverse solutions = 4.654339943235154\n",
      "After 292 iterations and 14260 oracle calls, mean reward of best M=3 diverse solutions = 4.654339943235154\n",
      "After 293 iterations and 14299 oracle calls, mean reward of best M=3 diverse solutions = 4.654339943235154\n",
      "After 294 iterations and 14334 oracle calls, mean reward of best M=3 diverse solutions = 4.654339943235154\n",
      "After 295 iterations and 14374 oracle calls, mean reward of best M=3 diverse solutions = 4.654339943235154\n",
      "After 296 iterations and 14413 oracle calls, mean reward of best M=3 diverse solutions = 4.654339943235154\n",
      "After 297 iterations and 14462 oracle calls, mean reward of best M=3 diverse solutions = 4.654339943235154\n",
      "After 298 iterations and 14508 oracle calls, mean reward of best M=3 diverse solutions = 4.663019097365049\n",
      "After 299 iterations and 14579 oracle calls, mean reward of best M=3 diverse solutions = 4.672570784320706\n",
      "After 300 iterations and 14611 oracle calls, mean reward of best M=3 diverse solutions = 4.672570784320706\n",
      "After 301 iterations and 14646 oracle calls, mean reward of best M=3 diverse solutions = 4.672570784320706\n",
      "After 302 iterations and 14689 oracle calls, mean reward of best M=3 diverse solutions = 4.672570784320706\n",
      "After 303 iterations and 14723 oracle calls, mean reward of best M=3 diverse solutions = 4.672570784320706\n",
      "After 304 iterations and 14762 oracle calls, mean reward of best M=3 diverse solutions = 4.672570784320706\n",
      "After 305 iterations and 14819 oracle calls, mean reward of best M=3 diverse solutions = 4.672570784320706\n",
      "After 306 iterations and 14877 oracle calls, mean reward of best M=3 diverse solutions = 4.673896117358467\n",
      "After 307 iterations and 14909 oracle calls, mean reward of best M=3 diverse solutions = 4.673896117358467\n",
      "After 308 iterations and 14944 oracle calls, mean reward of best M=3 diverse solutions = 4.673896117358467\n",
      "After 309 iterations and 14977 oracle calls, mean reward of best M=3 diverse solutions = 4.673896117358467\n",
      "After 310 iterations and 15018 oracle calls, mean reward of best M=3 diverse solutions = 4.673896117358467\n",
      "After 311 iterations and 15064 oracle calls, mean reward of best M=3 diverse solutions = 4.673896117358467\n",
      "After 312 iterations and 15098 oracle calls, mean reward of best M=3 diverse solutions = 4.673896117358467\n",
      "After 313 iterations and 15160 oracle calls, mean reward of best M=3 diverse solutions = 4.712265013387729\n",
      "After 314 iterations and 15192 oracle calls, mean reward of best M=3 diverse solutions = 4.712265013387729\n",
      "After 315 iterations and 15225 oracle calls, mean reward of best M=3 diverse solutions = 4.712265013387729\n",
      "After 316 iterations and 15257 oracle calls, mean reward of best M=3 diverse solutions = 4.712265013387729\n",
      "After 317 iterations and 15333 oracle calls, mean reward of best M=3 diverse solutions = 4.712265013387729\n",
      "After 318 iterations and 15403 oracle calls, mean reward of best M=3 diverse solutions = 4.712265013387729\n",
      "After 319 iterations and 15479 oracle calls, mean reward of best M=3 diverse solutions = 4.712265013387729\n",
      "After 320 iterations and 15552 oracle calls, mean reward of best M=3 diverse solutions = 4.722371873831503\n",
      "After 321 iterations and 15585 oracle calls, mean reward of best M=3 diverse solutions = 4.722371873831503\n",
      "After 322 iterations and 15617 oracle calls, mean reward of best M=3 diverse solutions = 4.722371873831503\n",
      "After 323 iterations and 15650 oracle calls, mean reward of best M=3 diverse solutions = 4.722371873831503\n",
      "After 324 iterations and 15717 oracle calls, mean reward of best M=3 diverse solutions = 4.722371873831503\n",
      "After 325 iterations and 15775 oracle calls, mean reward of best M=3 diverse solutions = 4.722371873831503\n",
      "After 326 iterations and 15831 oracle calls, mean reward of best M=3 diverse solutions = 4.722371873831503\n",
      "After 327 iterations and 15871 oracle calls, mean reward of best M=3 diverse solutions = 4.722501545947466\n",
      "After 328 iterations and 15904 oracle calls, mean reward of best M=3 diverse solutions = 4.722501545947466\n",
      "After 329 iterations and 15945 oracle calls, mean reward of best M=3 diverse solutions = 4.722501545947466\n",
      "After 330 iterations and 15985 oracle calls, mean reward of best M=3 diverse solutions = 4.722501545947466\n",
      "After 331 iterations and 16040 oracle calls, mean reward of best M=3 diverse solutions = 4.722501545947466\n"
     ]
    }
   ],
   "source": [
    "M = 3 # We set M=3 to search of a set of 3 diverse solutions \n",
    "budget = 16_000 if not SMOKE_TEST else 1 # total function evaluation budget \n",
    "acq_bsz = 32 if not SMOKE_TEST else 2 # acquisition batch size (number of points Thompson sampled from each trust region on each step)\n",
    "# Initialize M trust region states\n",
    "rank_ordered_trs = [TrustRegionState() for _ in range (M)] \n",
    "# Find the initial best diverse set of M solutions to center trust regions on \n",
    "best_m_xs, best_m_ys = recenter_trs(\n",
    "    train_x=train_x, \n",
    "    train_y=train_y, \n",
    "    rank_ordered_trs=rank_ordered_trs,\n",
    ")\n",
    "step = 0 \n",
    "n_evals = 0\n",
    "avg_reward_per_step = [np.array(best_m_ys).mean().item()] # for plotting, log the average reward of the M solutions found after each step\n",
    "n_func_evals_per_step = [n_evals] # for plotting, log the total number of function evaluations done after each step \n",
    "# Main optimizaton loop (continues until we use exceed function evaluation budget)\n",
    "while n_evals < budget:\n",
    "    if step > 0:\n",
    "        # update GP on new data \n",
    "        update_gp(\n",
    "            model=model,\n",
    "            mll=mll,\n",
    "            train_x=train_x[-acq_bsz*M:], # At most M * acq_bsz new points are added to the dataset on each step \n",
    "            train_y=train_y[-acq_bsz*M:],\n",
    "        )\n",
    "    # Asymetric acquisition: \n",
    "    #   to maintain diversity constraints, discard infeasible candidates from lower-ranking trust regions \n",
    "    all_feasible_x_next = [] \n",
    "    for tr_state in rank_ordered_trs:\n",
    "        # Generate a batch of candidates in trust region using global surrogate model\n",
    "        x_next_i = generate_batch(\n",
    "            tr_state=tr_state,\n",
    "            model=model,\n",
    "            dim=rover_objective.dim,\n",
    "            batch_size=acq_bsz, \n",
    "            lb=rover_objective.lb,\n",
    "            ub=rover_objective.ub,\n",
    "        )\n",
    "        # Remove infeasible candidates \n",
    "        temp = []\n",
    "        for x_cand in x_next_i:\n",
    "            x_cand = x_cand.unsqueeze(0) # (1,dim)\n",
    "            if is_feasible(cand_x=x_cand, higher_ranked_xs=all_feasible_x_next):\n",
    "                temp.append(x_cand) \n",
    "        all_feasible_x_next = all_feasible_x_next + temp \n",
    "        if len(temp) > 0:\n",
    "            x_next_i = torch.cat(temp, 0)\n",
    "            # Evaluate feasible candidates \n",
    "            y_next_i = f_batch(x_next_i)\n",
    "            # Update tr state \n",
    "            update_state(tr_state, y_next_i)\n",
    "            # Update dataset \n",
    "            train_x = torch.cat((train_x, x_next_i), 0)\n",
    "            train_y = torch.cat((train_y, y_next_i), 0)\n",
    "        \n",
    "    # Restart trust regions as needed according to individualized success/failure counts \n",
    "    for ix, tr_state in enumerate(rank_ordered_trs):\n",
    "        if tr_state.restart_triggered:\n",
    "            rank_ordered_trs[ix] = TrustRegionState()\n",
    "\n",
    "    # Recenter trust regions on the new best observed diverse set of M solutions \n",
    "    best_m_xs, best_m_ys = recenter_trs(\n",
    "        train_x=train_x, \n",
    "        train_y=train_y, \n",
    "        rank_ordered_trs=rank_ordered_trs,\n",
    "    )\n",
    "    avg_score_of_m_best = np.array(best_m_ys).mean().item()\n",
    "    n_evals = len(train_y) - n_initialization_points \n",
    "    if step % 10 == 0: # Print progress update every 10 iterations \n",
    "        print(f\"After {step+1} iterations and {n_evals} oracle calls, mean reward of best M={M} diverse solutions = {avg_score_of_m_best}\")\n",
    "    avg_reward_per_step.append(avg_score_of_m_best)\n",
    "    n_func_evals_per_step.append(n_evals)\n",
    "    step += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plot optimization performance\n",
    "Here we plot the optimization performance of ROBOT. The plot shows the average reward of the $M=3$ diverse solutions found by ROBOT after a certain number of function evaluations. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot avg reward vs function evaluations \n",
    "# Set figure size\n",
    "plt.figure(figsize=(8, 5))  \n",
    "# Plot global optimal value \n",
    "plt.plot([0, budget], [5.0, 5.0], \"k--\", lw=3, label=\"Global Optimal Value\")\n",
    "# Plot optimization performance \n",
    "plt.plot(n_func_evals_per_step, avg_reward_per_step, label=\"ROBOT\", linewidth=3.0)\n",
    "plt.title(f\"ROBOT Performance, Optimizing M={M} Diverse Solutions\") \n",
    "plt.xlabel(\"Number of Function Evaluations\")\n",
    "plt.ylabel(f\"Mean Reward of Best M={M} Diverse Solutions\")\n",
    "plt.grid(True)\n",
    "plt.legend()\n",
    "plt.tight_layout()\n",
    "plt.show();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Visualize ROBOT's optimized solutions\n",
    "Here, we depict $M=3$ diverse solutions found by ROBOT. Notice that all three solutions successfully naviagate from the start point to the \"goal\" point while avoiding the obstacles (the dark red rectanges). Also notice that the $M=3$ solutions found by ROBOT are diverse: they take distinctly different paths around the obstacles. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "_, ax = plt.subplots(1, 1, figsize=(8, 6))\n",
    "# Depict obstacles as dark red rectangles \n",
    "for i in range(len(rover_objective.obstacle_l)):\n",
    "    rect = patches.Rectangle(\n",
    "        (rover_objective.obstacle_l[i, 0], rover_objective.obstacle_l[i, 1]),\n",
    "        rover_objective.obstacle_delta,\n",
    "        rover_objective.obstacle_delta,\n",
    "        linewidth=1,\n",
    "        edgecolor=\"darkred\",\n",
    "        facecolor=\"darkred\",\n",
    "    )\n",
    "    ax.add_patch(rect) \n",
    "traj_colors = [\"magenta\", \"blue\", \"black\"]\n",
    "for ix, solution_x in enumerate(best_m_xs):\n",
    "    trajectory = rover_objective.get_trajectory_points(solution_x)\n",
    "    plt.plot(trajectory[:, 0], trajectory[:, 1], color=traj_colors[ix], linewidth=5.0, label=f\"Optimized Trajectory {ix+1}\")\n",
    "plt.plot(0.05, 0.05, \".g\", ms=25, label=\"Start\")  # Start\n",
    "plt.plot(0.95, 0.95, \".r\", ms=25, label=\"Goal\") # Goal\n",
    "plt.legend()\n",
    "plt.grid(True)\n",
    "# Add grid lines\n",
    "ax.grid(True)\n",
    "# Turn off axis labels (numbers) but keep ticks (and thus the grid lines)\n",
    "ax.set_xticklabels([])  # Remove x-axis tick labels\n",
    "ax.set_yticklabels([])  # Remove y-axis tick labels\n",
    "plt.title(f\"Visualizing the M={M} Solutions Found by ROBOT\")\n",
    "plt.show();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
